home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Mac Game Programming Gurus / TricksOfTheMacGameProgrammingGurus.iso / More Source / C⁄C++ / graph3D / graph3D source / g3D_MatrxOps.c < prev    next >
Text File  |  1993-09-17  |  6KB  |  335 lines
  1. /*
  2.     Copyright '89    Christopher Moll
  3.     all rights reserved
  4. */
  5.  
  6.  
  7. #include    "graph3D.h"
  8. #ifndef    _LSC3_
  9. #    include    <QuickDraw.h>
  10. #endif
  11.  
  12.  
  13. extern    Real    rotMatrx[3][3];
  14. extern    Real    scale;
  15. extern    Point    Origin;
  16.  
  17.  
  18. extern    Real    rotMatrx[3][3];
  19.  
  20. #ifdef FIXED_MATH
  21.  
  22. Fixed    _rotMatrx[3][3];
  23.  
  24. FxMatrxToMatrx(fxMat, matrx)
  25. register    Fixed    fxMat[3][3];
  26. register    Real    matrx[3][3];
  27. {
  28.     register    int    i, j;
  29.  
  30.     for (i = 0; i < 3; i++)
  31.         for (j = 0; j < 3; j++)
  32.             matrx[i][j] = FixToD(fxMat[i][j]);
  33. }
  34.  
  35. FxConv3VtoPt(vectP, cnvPntP)
  36. FxVector    *vectP;
  37. register    Point    *cnvPntP;
  38. {
  39.     FxVector result;
  40.  
  41.     FxMatrxMul(_rotMatrx, vectP, &result);
  42.  
  43.     cnvPntP->h = FixToi((result.y)) + Origin.h;
  44.     cnvPntP->v = FixToi((-result.z)) + Origin.v;
  45. }
  46.  
  47. /**** Matrix to rotate 3-vector on three axes ****/
  48. FxMkRotMat(Xrot, Yrot, Zrot, matrx)
  49. Real Xrot, Yrot, Zrot;
  50. register    Fixed    matrx[3][3];
  51. {
  52.     Real cXrot , cYrot , cZrot ;
  53.     Real sXrot , sYrot , sZrot ;
  54.  
  55.     cXrot = cos(Xrot);
  56.     cYrot = cos(Yrot);
  57.     cZrot = cos(Zrot);
  58.     sXrot = sin(Xrot);
  59.     sYrot = sin(Yrot);
  60.     sZrot = sin(Zrot);
  61.  
  62.  
  63.     matrx[0][0] = DToFix(cYrot * cZrot);
  64.     matrx[0][1] = DToFix(cZrot * sXrot * sYrot - sZrot * cXrot);
  65.     matrx[0][2] = DToFix(-(cXrot * cZrot * sYrot + sXrot * sZrot));
  66.     matrx[1][0] = DToFix(sZrot * cYrot);
  67.     matrx[1][1] = DToFix(sXrot * sYrot * sZrot + cXrot * cZrot);
  68.     matrx[1][2] = DToFix(-sYrot * sZrot * cXrot + sXrot * cZrot);
  69.     matrx[2][0] = DToFix(sYrot);
  70.     matrx[2][1] = DToFix(-sXrot * cYrot);
  71.     matrx[2][2] = DToFix(cXrot * cYrot);
  72. }
  73.  
  74.  
  75. FxMkXRotMat(Xrot, matrx)
  76. Real        Xrot;
  77. register    Fixed    matrx[3][3];
  78. {
  79.     Fixed    cXrot, sXrot;
  80.  
  81.     FxMkIDMat(matrx);
  82.  
  83.     cXrot = DToFix(cos(Xrot));
  84.     sXrot = DToFix(sin(Xrot));
  85.  
  86.     matrx[1][1] = cXrot;
  87.     matrx[1][2] = sXrot;
  88.     matrx[2][1] = -sXrot;
  89.     matrx[2][2] = cXrot;
  90. }
  91.  
  92. FxMkYRotMat(Yrot, matrx)
  93. Real        Yrot;
  94. register    Fixed    matrx[3][3];
  95. {
  96.     Fixed    cYrot, sYrot;
  97.  
  98.     FxMkIDMat(matrx);
  99.  
  100.     cYrot = DToFix(cos(Yrot));
  101.     sYrot = DToFix(sin(Yrot));
  102.  
  103.     matrx[0][0] = cYrot;
  104.     matrx[0][2] = -sYrot;
  105.     matrx[2][0] = sYrot;
  106.     matrx[2][2] = cYrot;
  107. }
  108.  
  109. FxMkZRotMat(Zrot, matrx)
  110. Real        Zrot;
  111. register    Fixed    matrx[3][3];
  112. {
  113.     Fixed    cZrot, sZrot;
  114.  
  115.     FxMkIDMat(matrx);
  116.  
  117.     cZrot = DToFix(cos(Zrot));
  118.     sZrot = DToFix(sin(Zrot));
  119.  
  120.     matrx[0][0] = cZrot;
  121.     matrx[0][1] = -sZrot;
  122.     matrx[1][0] = sZrot;
  123.     matrx[1][1] = cZrot;
  124. }
  125.  
  126. FxMkIDMat(matrx)
  127. register    Fixed    matrx[3][3];
  128. {
  129.     matrx[0][0] = FIX_1;
  130.     matrx[0][1] = FIX_0;
  131.     matrx[0][2] = FIX_0;
  132.     matrx[1][0] = FIX_0;
  133.     matrx[1][1] = FIX_1;
  134.     matrx[1][2] = FIX_0;
  135.     matrx[2][0] = FIX_0;
  136.     matrx[2][1] = FIX_0;
  137.     matrx[2][2] = FIX_1;
  138. }
  139.  
  140. FxMatrxMul(mat, vect, resVect)
  141. register    Fixed    mat[3][3];
  142. register    FxVector    *vect;
  143. register    FxVector    *resVect;
  144. {
  145.     resVect->x =
  146.         FixMul(mat[0][0], vect->x) +
  147.         FixMul(mat[0][1], vect->y) +
  148.         FixMul(mat[0][2], vect->z);
  149.     resVect->y =
  150.         FixMul(mat[1][0], vect->x) +
  151.         FixMul(mat[1][1], vect->y) +
  152.         FixMul(mat[1][2], vect->z);
  153.     resVect->z =
  154.         FixMul(mat[2][0], vect->x) +
  155.         FixMul(mat[2][1], vect->y) +
  156.         FixMul(mat[2][2], vect->z);
  157. }
  158.  
  159. FxMatrxByMatrx(mat1, mat2, resMat)
  160. register    Fixed    mat1[3][3], mat2[3][3], resMat[3][3];
  161. {
  162.     register    int    i, j;
  163.  
  164.     for(i = 0; i < 3; i++)
  165.         for(j = 0; j < 3; j++)
  166.             resMat[i][j] =    FixMul(mat1[i][0], mat2[0][j]) +
  167.                             FixMul(mat1[i][1], mat2[1][j]) +
  168.                             FixMul(mat1[i][2], mat2[2][j]);
  169. }
  170.  
  171. FxCopyMat(sorc, dest)
  172. register    cpyFx3Matrx    *sorc, *dest;
  173. {
  174.     *dest = *sorc;
  175. }
  176.  
  177. #endif
  178.  
  179.  
  180. /*---------------------------------------------------------------------------*/
  181.  
  182.  
  183.  
  184.  
  185. Conv3VtoPt(vectP, cnvPntP)
  186. Vector    *vectP;
  187. register    Point    *cnvPntP;
  188. {
  189.     Vector result;
  190.  
  191.     MatrxMul(rotMatrx, vectP, &result);
  192.  
  193.     cnvPntP->h = result.y + Origin.h;
  194.     cnvPntP->v = (-result.z) + Origin.v;
  195. }
  196.  
  197. MatrxMul(mat, vect, resVect)
  198. register    Real    mat[3][3];
  199. register    Vector    *vect;
  200. register    Vector    *resVect;
  201. {
  202.     resVect->x =
  203.         mat[0][0] * vect->x + mat[0][1] * vect->y + mat[0][2] * vect->z;
  204.     resVect->y =
  205.         mat[1][0] * vect->x + mat[1][1] * vect->y + mat[1][2] * vect->z;
  206.     resVect->z =
  207.         mat[2][0] * vect->x + mat[2][1] * vect->y + mat[2][2] * vect->z;
  208. }
  209.  
  210. matrxByMatrx(mat1, mat2, resMat)
  211. register    Real    mat1[3][3], mat2[3][3], resMat[3][3];
  212. {
  213.     register    int    i, j;
  214.  
  215.     for(i = 0; i < 3; i++)
  216.         for(j = 0; j < 3; j++)
  217.             resMat[i][j] =    mat1[i][0] * mat2[0][j] +
  218.                             mat1[i][1] * mat2[1][j] +
  219.                             mat1[i][2] * mat2[2][j];
  220. }
  221. typedef Real Matrix[3][3];
  222.  
  223. /**** Matrix to rotate 3-vector on three axes ****/
  224. MkRotMat(Xrot, Yrot, Zrot, matrx)
  225. Real Xrot, Yrot, Zrot;
  226. register    Matrix    matrx;
  227. {
  228.     Real cXrot , cYrot , cZrot ;
  229.     Real sXrot , sYrot , sZrot ;
  230.  
  231.     cXrot = cos(Xrot);
  232.     cYrot = cos(Yrot);
  233.     cZrot = cos(Zrot);
  234.     sXrot = sin(Xrot);
  235.     sYrot = sin(Yrot);
  236.     sZrot = sin(Zrot);
  237.  
  238.     matrx[0][0] = cYrot * cZrot;
  239.     matrx[0][1] = cZrot * sXrot * sYrot - sZrot * cXrot;
  240.     matrx[0][2] = -(cXrot * cZrot * sYrot + sXrot * sZrot);
  241.     matrx[1][0] = sZrot * cYrot;
  242.     matrx[1][1] = sXrot * sYrot * sZrot + cXrot * cZrot;
  243.     matrx[1][2] = -sYrot * sZrot * cXrot + sXrot * cZrot;
  244.     matrx[2][0] = sYrot;
  245.     matrx[2][1] = -sXrot * cYrot;
  246.     matrx[2][2] = cXrot * cYrot;
  247. }
  248.  
  249.  
  250. MatrxByMatrx(mat1, mat2, resMat)
  251. register    Real    mat1[3][3], mat2[3][3], resMat[3][3];
  252. {
  253.     register    int    i, j;
  254.  
  255.     for(i = 0; i < 3; i++)
  256.         for(j = 0; j < 3; j++)
  257.             resMat[i][j] =    mat1[i][0] * mat2[0][j] +
  258.                             mat1[i][1] * mat2[1][j] +
  259.                             mat1[i][2] * mat2[2][j];
  260. }
  261.  
  262.  
  263. CopyMat(sorc, dest)
  264. register    cpy3Matrx    *sorc, *dest;
  265. {
  266.     *dest = *sorc;
  267. }
  268.  
  269. MkIDMat(matrx)
  270. register    Real    matrx[3][3];
  271. {
  272.     matrx[0][0] = 1;
  273.     matrx[0][1] = 0;
  274.     matrx[0][2] = 0;
  275.     matrx[1][0] = 0;
  276.     matrx[1][1] = 1;
  277.     matrx[1][2] = 0;
  278.     matrx[2][0] = 0;
  279.     matrx[2][1] = 0;
  280.     matrx[2][2] = 1;
  281. }
  282.  
  283.  
  284.  
  285. MkXRotMat(Xrot, matrx)
  286. Real        Xrot;
  287. register    Real    matrx[3][3];
  288. {
  289.     Real    cXrot, sXrot;
  290.  
  291.     MkIDMat(matrx);
  292.  
  293.     cXrot = cos(Xrot);
  294.     sXrot = sin(Xrot);
  295.  
  296.     matrx[1][1] = cXrot;
  297.     matrx[1][2] = sXrot;
  298.     matrx[2][1] = -sXrot;
  299.     matrx[2][2] = cXrot;
  300. }
  301.  
  302. MkYRotMat(Yrot, matrx)
  303. Real        Yrot;
  304. register    Real    matrx[3][3];
  305. {
  306.     Real    cYrot, sYrot;
  307.  
  308.     MkIDMat(matrx);
  309.  
  310.     cYrot = cos(Yrot);
  311.     sYrot = sin(Yrot);
  312.  
  313.     matrx[0][0] = cYrot;
  314.     matrx[0][2] = -sYrot;
  315.     matrx[2][0] = sYrot;
  316.     matrx[2][2] = cYrot;
  317. }
  318.  
  319. MkZRotMat(Zrot, matrx)
  320. Real        Zrot;
  321. register    Real    matrx[3][3];
  322. {
  323.     Real    cZrot, sZrot;
  324.  
  325.     MkIDMat(matrx);
  326.  
  327.     cZrot = cos(Zrot);
  328.     sZrot = sin(Zrot);
  329.  
  330.     matrx[0][0] = cZrot;
  331.     matrx[0][1] = -sZrot;
  332.     matrx[1][0] = sZrot;
  333.     matrx[1][1] = cZrot;
  334. }
  335.